package models

import (
	"time"

	"github.com/beego/beego/v2/client/orm"
)

// MeituanGroup 美团团购活动
type MeituanGroup struct {
	BaseModel
	MeituanId      int64  `orm:"index" json:"meituan_id"`           // 关联美团配置ID
	StoreId        int64  `orm:"index" json:"store_id"`             // 门店ID
	StoreName      string `orm:"size(100)" json:"store_name"`       // 门店名称
	Title          string `orm:"size(200)" json:"title"`            // 团购活动标题
	Description    string `orm:"size(1000)" json:"description"`     // 团购活动描述
	OriginalPrice  int    `json:"original_price"`                   // 原价(分)
	GroupPrice     int    `json:"group_price"`                      // 团购价(分)
	MinCount       int    `json:"min_count"`                        // 最小开团人数
	MaxCount       int    `json:"max_count"`                        // 最大开团人数
	StartTime      int64  `orm:"index" json:"start_time"`           // 活动开始时间戳(毫秒)
	EndTime        int64  `orm:"index" json:"end_time"`             // 活动结束时间戳(毫秒)
	Status         int    `orm:"default(1)" json:"status"`          // 状态：0-禁用，1-启用
	MeituanGroupId string `orm:"size(100)" json:"meituan_group_id"` // 美团团购ID
	SoldCount      int    `orm:"default(0)" json:"sold_count"`      // 已售数量
	ActivityRules  string `orm:"type(text)" json:"activity_rules"`  // 活动规则
	ServiceTerms   string `orm:"type(text)" json:"service_terms"`   // 服务条款
	Images         string `orm:"type(text)" json:"images"`          // 团购图片，JSON数组
	LastSyncTime   int64  `json:"last_sync_time"`                   // 最后同步时间戳(毫秒)
}

// MeituanGroupOrder 美团团购订单
type MeituanGroupOrder struct {
	BaseModel
	MeituanGroupId   int64  `orm:"index" json:"meituan_group_id"`    // 关联美团团购活动ID
	MeituanId        int64  `orm:"index" json:"meituan_id"`          // 关联美团配置ID
	StoreId          int64  `orm:"index" json:"store_id"`            // 门店ID
	StoreName        string `orm:"size(100)" json:"store_name"`      // 门店名称
	OrderId          string `orm:"size(100);unique" json:"order_id"` // 美团订单号
	OrderTime        int64  `orm:"index" json:"order_time"`          // 下单时间戳(毫秒)
	GroupTitle       string `orm:"size(200)" json:"group_title"`     // 团购活动标题
	UserName         string `orm:"size(100)" json:"user_name"`       // 用户姓名
	UserPhone        string `orm:"size(20)" json:"user_phone"`       // 用户电话
	Quantity         int    `json:"quantity"`                        // 购买数量
	TotalPrice       int    `json:"total_price"`                     // 总金额(分)
	Status           string `orm:"size(50)" json:"status"`           // 订单状态
	ProcessStatus    string `orm:"size(50)" json:"process_status"`   // 处理状态：pending-待处理，accepted-已接单，rejected-已拒绝，completed-已完成
	IsProcessed      int    `orm:"default(0)" json:"is_processed"`   // 是否已处理：0-未处理，1-已处理
	ProcessTime      int64  `json:"process_time"`                    // 处理时间戳(毫秒)
	RefundStatus     string `orm:"size(50)" json:"refund_status"`    // 退款状态
	Remark           string `orm:"size(500)" json:"remark"`          // 备注
	MeituanRemark    string `orm:"size(500)" json:"meituan_remark"`  // 美团备注
	VoucherCode      string `orm:"size(100)" json:"voucher_code"`    // 团购券码
	VoucherValidTime int64  `json:"voucher_valid_time"`              // 券有效期时间戳(毫秒)
	IsUsed           int    `orm:"default(0)" json:"is_used"`        // 是否已使用：0-未使用，1-已使用
	UseTime          int64  `json:"use_time"`                        // 使用时间戳(毫秒)
}

// 初始化
func init() {
	// 注册模型
	orm.RegisterModel(new(MeituanGroup), new(MeituanGroupOrder))
}

// GetMeituanGroupList 获取美团团购活动列表
func GetMeituanGroupList(page, pageSize int, filters map[string]interface{}) ([]*MeituanGroup, int64, error) {
	o := orm.NewOrm()
	query := o.QueryTable(new(MeituanGroup)).Filter("is_deleted", 0)

	// 应用过滤条件
	if storeId, ok := filters["store_id"].(int64); ok && storeId > 0 {
		query = query.Filter("store_id", storeId)
	}
	if status, ok := filters["status"].(int); ok && status != -1 {
		query = query.Filter("status", status)
	}
	if meituanId, ok := filters["meituan_id"].(int64); ok && meituanId > 0 {
		query = query.Filter("meituan_id", meituanId)
	}
	if title, ok := filters["title"].(string); ok && title != "" {
		query = query.Filter("title__icontains", title)
	}

	// 计算总数
	total, err := query.Count()
	if err != nil {
		return nil, 0, err
	}

	// 分页查询
	var list []*MeituanGroup
	_, err = query.OrderBy("-id").Limit(pageSize).Offset((page - 1) * pageSize).All(&list)
	if err != nil {
		return nil, 0, err
	}

	return list, total, nil
}

// AddMeituanGroup 添加美团团购活动
func AddMeituanGroup(group *MeituanGroup) (int64, error) {
	o := orm.NewOrm()
	id, err := o.Insert(group)
	return id, err
}

// GetMeituanGroupById 根据ID获取美团团购活动
func GetMeituanGroupById(id int64) (*MeituanGroup, error) {
	o := orm.NewOrm()
	group := &MeituanGroup{}
	group.Id = id
	err := o.Read(group)
	if err != nil {
		return nil, err
	}
	if group.IsDeleted == 1 {
		return nil, orm.ErrNoRows
	}
	return group, nil
}

// UpdateMeituanGroup 更新美团团购活动
func UpdateMeituanGroup(group *MeituanGroup) error {
	o := orm.NewOrm()
	_, err := o.Update(group)
	return err
}

// DeleteMeituanGroup 删除美团团购活动
func DeleteMeituanGroup(id int64) error {
	o := orm.NewOrm()
	group := &MeituanGroup{}
	group.Id = id
	err := o.Read(group)
	if err != nil {
		return err
	}
	group.IsDeleted = 1
	_, err = o.Update(group, "IsDeleted")
	return err
}

// GetMeituanGroupOrderList 获取美团团购订单列表
func GetMeituanGroupOrderList(page, pageSize int, filters map[string]interface{}) ([]*MeituanGroupOrder, int64, error) {
	o := orm.NewOrm()
	query := o.QueryTable(new(MeituanGroupOrder)).Filter("is_deleted", 0)

	// 应用过滤条件
	if storeId, ok := filters["store_id"].(int64); ok && storeId > 0 {
		query = query.Filter("store_id", storeId)
	}
	if meituanId, ok := filters["meituan_id"].(int64); ok && meituanId > 0 {
		query = query.Filter("meituan_id", meituanId)
	}
	if meituanGroupId, ok := filters["meituan_group_id"].(int64); ok && meituanGroupId > 0 {
		query = query.Filter("meituan_group_id", meituanGroupId)
	}
	if status, ok := filters["status"].(string); ok && status != "" {
		query = query.Filter("status", status)
	}
	if processStatus, ok := filters["process_status"].(string); ok && processStatus != "" {
		query = query.Filter("process_status", processStatus)
	}
	if isProcessed, ok := filters["is_processed"].(int); ok && isProcessed != -1 {
		query = query.Filter("is_processed", isProcessed)
	}
	if isUsed, ok := filters["is_used"].(int); ok && isUsed != -1 {
		query = query.Filter("is_used", isUsed)
	}
	if startTime, ok := filters["start_time"].(int64); ok && startTime > 0 {
		query = query.Filter("order_time__gte", startTime)
	}
	if endTime, ok := filters["end_time"].(int64); ok && endTime > 0 {
		query = query.Filter("order_time__lte", endTime)
	}

	// 计算总数
	total, err := query.Count()
	if err != nil {
		return nil, 0, err
	}

	// 分页查询
	var list []*MeituanGroupOrder
	_, err = query.OrderBy("-id").Limit(pageSize).Offset((page - 1) * pageSize).All(&list)
	if err != nil {
		return nil, 0, err
	}

	return list, total, nil
}

// AddMeituanGroupOrder 添加美团团购订单
func AddMeituanGroupOrder(order *MeituanGroupOrder) (int64, error) {
	o := orm.NewOrm()
	id, err := o.Insert(order)
	return id, err
}

// GetMeituanGroupOrderById 根据ID获取美团团购订单
func GetMeituanGroupOrderById(id int64) (*MeituanGroupOrder, error) {
	o := orm.NewOrm()
	order := &MeituanGroupOrder{}
	order.Id = id
	err := o.Read(order)
	if err != nil {
		return nil, err
	}
	if order.IsDeleted == 1 {
		return nil, orm.ErrNoRows
	}
	return order, nil
}

// GetMeituanGroupOrderByOrderId 根据美团订单号获取订单
func GetMeituanGroupOrderByOrderId(orderId string) (*MeituanGroupOrder, error) {
	o := orm.NewOrm()
	order := &MeituanGroupOrder{}
	err := o.QueryTable(new(MeituanGroupOrder)).
		Filter("order_id", orderId).
		Filter("is_deleted", 0).
		One(order)
	if err != nil {
		return nil, err
	}
	return order, nil
}

// UpdateMeituanGroupOrder 更新美团团购订单
func UpdateMeituanGroupOrder(order *MeituanGroupOrder) error {
	o := orm.NewOrm()
	_, err := o.Update(order)
	return err
}

// ProcessMeituanGroupOrder 处理美团团购订单
func ProcessMeituanGroupOrder(id int64, status int) error {
	o := orm.NewOrm()
	order := &MeituanGroupOrder{}
	order.Id = id
	err := o.Read(order)
	if err != nil {
		return err
	}

	// 设置处理状态
	switch status {
	case 1: // 确认订单
		order.ProcessStatus = "accepted"
	case 2: // 拒绝订单
		order.ProcessStatus = "rejected"
	case 3: // 完成订单
		order.ProcessStatus = "completed"
	}

	order.IsProcessed = 1
	order.ProcessTime = time.Now().Unix() // 使用当前时间的毫秒时间戳

	_, err = o.Update(order)
	return err
}

// UseMeituanGroupOrder 使用美团团购券
func UseMeituanGroupOrder(id int64) error {
	o := orm.NewOrm()
	order := &MeituanGroupOrder{}
	order.Id = id
	err := o.Read(order)
	if err != nil {
		return err
	}

	order.IsUsed = 1
	order.UseTime = time.Now().Unix() // 使用当前时间的毫秒时间戳

	_, err = o.Update(order)
	return err
}

// DeleteMeituanGroupOrder 删除美团团购订单
func DeleteMeituanGroupOrder(id int64) error {
	o := orm.NewOrm()
	order := &MeituanGroupOrder{}
	order.Id = id
	err := o.Read(order)
	if err != nil {
		return err
	}
	order.IsDeleted = 1
	_, err = o.Update(order, "IsDeleted")
	return err
}

// GetMeituanGroupOrderStatistics 获取美团团购订单统计信息
func GetMeituanGroupOrderStatistics(storeId int64) (map[string]interface{}, error) {
	o := orm.NewOrm()

	// 基础查询
	query := o.QueryTable(new(MeituanGroupOrder)).Filter("is_deleted", 0)
	if storeId > 0 {
		query = query.Filter("store_id", storeId)
	}

	// 总订单数
	totalOrders, err := query.Count()
	if err != nil {
		return nil, err
	}

	// 已处理订单数
	processedOrders, err := query.Filter("is_processed", 1).Count()
	if err != nil {
		return nil, err
	}

	// 已使用券数
	usedOrders, err := query.Filter("is_used", 1).Count()
	if err != nil {
		return nil, err
	}

	// 待处理订单数
	pendingOrders, err := query.Filter("is_processed", 0).Count()
	if err != nil {
		return nil, err
	}

	// 总销售额（已使用券）
	var totalSales int64
	totalSales, err = query.Filter("is_used", 1).Count()
	if err != nil {
		totalSales = 0
	} else {
		// 计算总金额
		var totalAmount int64
		_, err = o.Raw("SELECT COALESCE(SUM(total_price), 0) FROM meituan_group_order WHERE is_deleted = 0 AND is_used = 1 AND store_id = ?", storeId).QueryRows(&totalAmount)
		if err != nil {
			totalAmount = 0
		}
		totalSales = totalAmount
	}

	// 今日订单数
	today := time.Now().Format("2006-01-02")
	todayStart, _ := time.ParseInLocation("2006-01-02", today, time.Local)
	todayEnd := todayStart.Add(24 * time.Hour)

	todayOrders, err := query.Filter("order_time__gte", todayStart.Unix()).Filter("order_time__lt", todayEnd.Unix()).Count()
	if err != nil {
		todayOrders = 0
	}

	// 今日使用券数
	todayUsed, err := query.Filter("order_time__gte", todayStart.Unix()).Filter("order_time__lt", todayEnd.Unix()).Filter("is_used", 1).Count()
	if err != nil {
		todayUsed = 0
	}

	return map[string]interface{}{
		"total_orders":     totalOrders,
		"processed_orders": processedOrders,
		"used_orders":      usedOrders,
		"pending_orders":   pendingOrders,
		"total_sales":      totalSales,
		"today_orders":     todayOrders,
		"today_used":       todayUsed,
	}, nil
}

// GetMeituanGroupOrderIdsByStore 根据门店获取订单ID列表（用于去重）
func GetMeituanGroupOrderIdsByStore(storeId int64) (map[string]bool, error) {
	o := orm.NewOrm()
	query := o.QueryTable(new(MeituanGroupOrder)).Filter("is_deleted", 0)
	if storeId > 0 {
		query = query.Filter("store_id", storeId)
	}

	var orders []*MeituanGroupOrder
	_, err := query.All(&orders, "order_id")
	if err != nil {
		return nil, err
	}

	result := make(map[string]bool)
	for _, order := range orders {
		result[order.OrderId] = true
	}

	return result, nil
}

// BatchAddMeituanGroupOrders 批量添加美团团购订单
func BatchAddMeituanGroupOrders(orders []*MeituanGroupOrder) error {
	if len(orders) == 0 {
		return nil
	}

	o := orm.NewOrm()
	_, err := o.InsertMulti(len(orders), orders)
	return err
}
